FEXPConcurency.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Provides base functionality for concurrency and parallelism.
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPCONCURENCY_H_
#define _CFEXPCONCURENCY_H_
#include "FEXPCommon.h"

// definition of constant for time measure
#define NANO_SEC                                 1.0E-9
// thread barrier used within the FEXP server
#define SERVER_THREAD_BARRIER CFEXPThreadGeneralBarrier

// --> Windows specifics
// macro for checking windows version for supporting speciffic functionality
// specific to development in MS Visual Studio (2015)
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383745.aspx
// https://msdn.microsoft.com/en-us/library/6sehtctf.aspx
// https://msdn.microsoft.com/cs-cz/library/windows/desktop/aa383745(v=vs.85).aspx
// it checks if windows version supports barriers
#define FEXPCOMMON_IS_WIN_BARR_SUPPORTED (NTDDI_VERSION <= FEXPCOMMON_MY_WIN_VERSION_FOR_COMPILATION)

class CFEXPAsyncRunner
{
public:
  using t_Procedure = std::function<void(void)>;
  static bool RunProcedureTask(t_Procedure procedure, bool progressbar);
  static bool RunProcedureTask(t_Procedure procedure, bool progressbar, std::string proc_desc, bool check_time_elapsed);
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class ICFEXPConcurrencyBase
{
public:
  virtual ~ICFEXPConcurrencyBase() { }

  // pure virtual member functions
  virtual void Dispose() = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class ICFEXPSynchrThreadBarrier
  : public ICFEXPConcurrencyBase
{
public:
  ICFEXPSynchrThreadBarrier(size_t thrd_count) : _initial_thrd_count(thrd_count) { }
  virtual ~ICFEXPSynchrThreadBarrier() { }

  // barrier instance creator
  template<typename TBarrier>
  static typename std::enable_if<std::is_base_of<ICFEXPSynchrThreadBarrier, TBarrier>::value, Ptr<TBarrier>>::type
  GetInstance(std::size_t thread_count);

  // virtual member functions
  virtual void   SynchronizeThreads() = 0;
  virtual size_t GetNumberOfThreads() { return _initial_thrd_count; }
protected:
  const size_t _initial_thrd_count;
private:
  // [no private members  ] -----------------------------
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TBarrier>
typename std::enable_if<std::is_base_of<ICFEXPSynchrThreadBarrier, TBarrier>::value, Ptr<TBarrier>>::type
ICFEXPSynchrThreadBarrier::GetInstance(std::size_t thread_count)
//--------------------------------------------------------------------------------------
{
  return (thread_count != 0) ?
    CFEXPDataManager<TBarrier>::SafeAllocInstance(thread_count)
    : Ptr<TBarrier>(nullptr);
}


class CFEXPThreadGeneralBarrier
  : public ICFEXPSynchrThreadBarrier
{
public:
  explicit CFEXPThreadGeneralBarrier(std::size_t thread_count);
  virtual ~CFEXPThreadGeneralBarrier() { Dispose(); }

  // override of virtual member functions
  virtual void SynchronizeThreads() override;
  // override of virtual member functions
  virtual void Dispose           () override { }
protected:
  // [no protected members] -----------------------------
private:
  enum BarrierState : unsigned char { e_INCR, e_DECR };
  std::mutex              _mtx;
  std::condition_variable _cond_var;
  // info about the state of barrier
  size_t       _thrd_counter;
  BarrierState _barrier_state;
};


class CFEXPThreadWin8PLBarrier
  : public ICFEXPSynchrThreadBarrier
{
public:
  explicit CFEXPThreadWin8PLBarrier(std::size_t thread_count);
  virtual ~CFEXPThreadWin8PLBarrier() { Dispose(); }

  // override of virtual member functions
  virtual void SynchronizeThreads() override;
  virtual void Dispose           () override;
protected:
  // [no protected members] -----------------------------
private:
  // state of barrier information
  bool                    _is_disposed;
  LONG                    _thrd_counter;
#if FEXPCOMMON_IS_WIN_BARR_SUPPORTED
  SYNCHRONIZATION_BARRIER _barrier;
#endif
};


class ICFEXPThreadBase
  : public ICFEXPConcurrencyBase
{
public:
  virtual ~ICFEXPThreadBase() { }

  // pure virtual member functions
  virtual void StartThread() = 0;
  virtual void Join       () = 0;
  virtual void Detach     () = 0;
  virtual void Cancel     () = 0;
  virtual bool Canceling  () = 0;

  // template functions for handling with input data
  template<typename... VarArgs>
  std::tuple<VarArgs...> GetInputDataTuple(VarArgs&&... args) { return std::tuple<VarArgs...>(args...); }
  // empty function for data setting -- to override in child
  template<typename TFunc, typename... VarArgs>
  void SetInputData(std::function<TFunc> func, std::tuple<VarArgs...> args) { }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

//https://stackoverflow.com/questions/13893060/i-want-to-kill-a-stdthread-using-its-thread-object
class CFEXPCancelThreadException
  : public virtual std::exception
{
public:
  virtual char const* what() const override { return "Thread interrupted!!!"; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

template<typename TThread>
void ThrowIfCancelRequest() noexcept(false)
{
  auto test1 = TThread::_flag_ptr;
  if (!test1)
    return;
  auto test2 = TThread::_flag_ptr->load();
  if (!test2)
    return;
  // throw cancel exception
  throw CFEXPCancelThreadException();
}


template<typename TFunc, typename... VarArgs>
class CFEXPCppThread
  : public ICFEXPThreadBase
{
public:
  CFEXPCppThread() { }
  CFEXPCppThread(std::function<TFunc> func, VarArgs & ...args);
  virtual ~CFEXPCppThread() { _flag_ptr = nullptr; }
  // override pure virtual member fucntion
  virtual void StartThread() override;
  virtual void Join       () override;
  virtual void Detach     () override;
  virtual void Cancel     () override;
  virtual bool Canceling  () override;
  // override pure virtual member function to dispose object -- empty
  virtual void Dispose    () override { }

  // override base class template function -- little trick :-)
  void SetInputData(std::function<TFunc> func, std::tuple<VarArgs...> args);
protected:
  friend void ThrowIfCancelRequest<CFEXPCppThread<TFunc, VarArgs...>>();
private:
  std::function<TFunc>   _thread_func;
  std::tuple<VarArgs...> _thread_args;
  Ptr<std::thread>       _thread;
  //
  static thread_local std::atomic_bool * _flag_ptr;
  std::atomic_bool                       _flag;
  // lazy thread creation with variable input parameters
  template<std::size_t... Idx>
  Ptr<std::thread> create_thread(const std::tuple<VarArgs...> & tuple, std::index_sequence<Idx...>);
  template<std::size_t... Idx>
  void runner(std::function<TFunc> func, const std::tuple<VarArgs...> & tuple, std::index_sequence<Idx...>);
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs>
thread_local std::atomic_bool * CFEXPCppThread<TFunc, VarArgs...>::_flag_ptr = nullptr;
//--------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs>
CFEXPCppThread<TFunc, VarArgs...>::CFEXPCppThread(std::function<TFunc> func, VarArgs & ...args)
  : ICFEXPThreadBase(), _flag(false)
//--------------------------------------------------------------------------------------
{
  SetInputData(func, GetInputDataTuple(args...));
}

//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs>
void CFEXPCppThread<TFunc, VarArgs...>::SetInputData(std::function<TFunc> func, std::tuple<VarArgs...> args)
//--------------------------------------------------------------------------------------
{
  _thread_func = func;
  _thread_args = args;
}

//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs>
void CFEXPCppThread<TFunc, VarArgs...>::StartThread()
//--------------------------------------------------------------------------------------
{
  if (_thread)
    return;
  _thread = create_thread(_thread_args, std::index_sequence_for<VarArgs...>());
}

//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs>
void CFEXPCppThread<TFunc, VarArgs...>::Join()
//--------------------------------------------------------------------------------------
{
  if (!_thread && !_thread->joinable())
    return;
  _thread->join();
}

//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs>
void CFEXPCppThread<TFunc, VarArgs...>::Detach()
//--------------------------------------------------------------------------------------
{
  if (!_thread && !_thread->joinable())
    return;
  _thread->detach();
}

//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs>
void CFEXPCppThread<TFunc, VarArgs...>::Cancel()
//--------------------------------------------------------------------------------------
{
  _flag.store(true);
}

//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs>
bool CFEXPCppThread<TFunc, VarArgs...>::Canceling()
//--------------------------------------------------------------------------------------
{
  return _flag.load();
}

//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs> template<std::size_t... Idx>
Ptr<std::thread> CFEXPCppThread<TFunc, VarArgs...>::create_thread(const std::tuple<VarArgs...> & tuple, std::index_sequence<Idx...>)
//--------------------------------------------------------------------------------------
{
  // 1. version without runner
  // return CFEXPDataManager<std::thread>::SafeAllocInstance(std::bind(_thread_func, std::get<Idx>(tuple)...));
  // 2. version with runner allow interrupt the thread
  auto lambda_runner = [this] { runner(_thread_func, _thread_args, std::index_sequence_for<VarArgs...>()); };
  return CFEXPDataManager<std::thread>::SafeAllocInstance(std::bind(lambda_runner));
}

//--------------------------------------------------------------------------------------
template<typename TFunc, typename... VarArgs> template<std::size_t... Idx>
void CFEXPCppThread<TFunc, VarArgs...>::runner(std::function<TFunc> func, const std::tuple<VarArgs...> & tuple, std::index_sequence<Idx...>)
//--------------------------------------------------------------------------------------
{
  _flag_ptr = &_flag;
  _thread_func(std::get<Idx>(tuple)...);
}


class CFEXPConcurencyTools
{
public:
  static Ptr<std::vector<size_t>> GetCpuThreadIds     (size_t threads_num);
  static size_t                   GetCpuThreadIdToItem(size_t number, size_t threads_num, size_t item_count);
  static size_t                   GetNumOfCpuThreads  ();
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

#endif // !_CFEXPCONCURENCY_H_